{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Datawhale 零基础入门数据挖掘-Task3 特征工程\n",
    "\n",
    "## 三、 特征工程目标\n",
    "\n",
    "Tip:此部分为零基础入门数据挖掘的 Task3 特征工程 部分，带你来了解各种特征工程以及分析方法，欢迎大家后续多多交流。\n",
    "\n",
    "**赛题：零基础入门数据挖掘 - 二手车交易价格预测**\n",
    "\n",
    "地址：https://tianchi.aliyun.com/competition/entrance/231784/introduction?spm=5176.12281957.1004.1.38b02448ausjSX "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 特征工程目标\n",
    "\n",
    "* 对于特征进行进一步分析，并对于数据进行处理\n",
    "\n",
    "* 完成对于特征工程的分析，并对于数据进行一些图表或者文字总结并打卡。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2  内容介绍\n",
    "常见的特征工程包括：\n",
    "1. 异常处理：\n",
    "    - 通过箱线图（或 3-Sigma）分析删除异常值；\n",
    "    - BOX-COX 转换（处理有偏分布）；\n",
    "    - 长尾截断；\n",
    "2. 特征归一化/标准化：\n",
    "    - 标准化（转换为标准正态分布）；\n",
    "    - 归一化（抓换到 [0,1] 区间）；\n",
    "    - 针对幂律分布，可以采用公式： $log(\\frac{1+x}{1+median})$\n",
    "3. 数据分桶：\n",
    "    - 等频分桶；\n",
    "    - 等距分桶；\n",
    "    - Best-KS 分桶（类似利用基尼指数进行二分类）；\n",
    "    - 卡方分桶；\n",
    "4. 缺失值处理：\n",
    "    - 不处理（针对类似 XGBoost 等树模型）；\n",
    "    - 删除（缺失数据太多）；\n",
    "    - 插值补全，包括均值/中位数/众数/建模预测/多重插补/压缩感知补全/矩阵补全等；\n",
    "    - 分箱，缺失值一个箱；\n",
    "5. 特征构造：\n",
    "    - 构造统计量特征，报告计数、求和、比例、标准差等；\n",
    "    - 时间特征，包括相对时间和绝对时间，节假日，双休日等；\n",
    "    - 地理信息，包括分箱，分布编码等方法；\n",
    "    - 非线性变换，包括 log/ 平方/ 根号等；\n",
    "    - 特征组合，特征交叉；\n",
    "    - 仁者见仁，智者见智。\n",
    "6. 特征筛选\n",
    "    - 过滤式（filter）：先对数据进行特征选择，然后在训练学习器，常见的方法有 Relief/方差选择发/相关系数法/卡方检验法/互信息法；\n",
    "    - 包裹式（wrapper）：直接把最终将要使用的学习器的性能作为特征子集的评价准则，常见方法有 LVM（Las Vegas Wrapper） ；\n",
    "    - 嵌入式（embedding）：结合过滤式和包裹式，学习器训练过程中自动进行了特征选择，常见的有 lasso 回归；\n",
    "7. 降维\n",
    "    - PCA/ LDA/ ICA；\n",
    "    - 特征选择也是一种降维。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 代码示例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.0 导入数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from operator import itemgetter\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150000, 30)\n",
      "(50000, 30)\n"
     ]
    }
   ],
   "source": [
    "train = pd.read_csv('train.csv', sep=' ')\n",
    "test = pd.read_csv('testA.csv', sep=' ')\n",
    "print(train.shape)\n",
    "print(test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>regDate</th>\n",
       "      <th>model</th>\n",
       "      <th>brand</th>\n",
       "      <th>bodyType</th>\n",
       "      <th>fuelType</th>\n",
       "      <th>gearbox</th>\n",
       "      <th>power</th>\n",
       "      <th>kilometer</th>\n",
       "      <th>notRepairedDamage</th>\n",
       "      <th>...</th>\n",
       "      <th>v_5</th>\n",
       "      <th>v_6</th>\n",
       "      <th>v_7</th>\n",
       "      <th>v_8</th>\n",
       "      <th>v_9</th>\n",
       "      <th>v_10</th>\n",
       "      <th>v_11</th>\n",
       "      <th>v_12</th>\n",
       "      <th>v_13</th>\n",
       "      <th>v_14</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>736</td>\n",
       "      <td>20040402</td>\n",
       "      <td>30.0</td>\n",
       "      <td>6</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>60</td>\n",
       "      <td>12.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.235676</td>\n",
       "      <td>0.101988</td>\n",
       "      <td>0.129549</td>\n",
       "      <td>0.022816</td>\n",
       "      <td>0.097462</td>\n",
       "      <td>-2.881803</td>\n",
       "      <td>2.804097</td>\n",
       "      <td>-2.420821</td>\n",
       "      <td>0.795292</td>\n",
       "      <td>0.914762</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2262</td>\n",
       "      <td>20030301</td>\n",
       "      <td>40.0</td>\n",
       "      <td>1</td>\n",
       "      <td>2.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>15.0</td>\n",
       "      <td>-</td>\n",
       "      <td>...</td>\n",
       "      <td>0.264777</td>\n",
       "      <td>0.121004</td>\n",
       "      <td>0.135731</td>\n",
       "      <td>0.026597</td>\n",
       "      <td>0.020582</td>\n",
       "      <td>-4.900482</td>\n",
       "      <td>2.096338</td>\n",
       "      <td>-1.030483</td>\n",
       "      <td>-1.722674</td>\n",
       "      <td>0.245522</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>14874</td>\n",
       "      <td>20040403</td>\n",
       "      <td>115.0</td>\n",
       "      <td>15</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>163</td>\n",
       "      <td>12.5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.251410</td>\n",
       "      <td>0.114912</td>\n",
       "      <td>0.165147</td>\n",
       "      <td>0.062173</td>\n",
       "      <td>0.027075</td>\n",
       "      <td>-4.846749</td>\n",
       "      <td>1.803559</td>\n",
       "      <td>1.565330</td>\n",
       "      <td>-0.832687</td>\n",
       "      <td>-0.229963</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>71865</td>\n",
       "      <td>19960908</td>\n",
       "      <td>109.0</td>\n",
       "      <td>10</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>193</td>\n",
       "      <td>15.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.274293</td>\n",
       "      <td>0.110300</td>\n",
       "      <td>0.121964</td>\n",
       "      <td>0.033395</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>-4.509599</td>\n",
       "      <td>1.285940</td>\n",
       "      <td>-0.501868</td>\n",
       "      <td>-2.438353</td>\n",
       "      <td>-0.478699</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>111080</td>\n",
       "      <td>20120103</td>\n",
       "      <td>110.0</td>\n",
       "      <td>5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>68</td>\n",
       "      <td>5.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>...</td>\n",
       "      <td>0.228036</td>\n",
       "      <td>0.073205</td>\n",
       "      <td>0.091880</td>\n",
       "      <td>0.078819</td>\n",
       "      <td>0.121534</td>\n",
       "      <td>-1.896240</td>\n",
       "      <td>0.910783</td>\n",
       "      <td>0.931110</td>\n",
       "      <td>2.834518</td>\n",
       "      <td>1.923482</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5 rows × 30 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     name   regDate  model  brand  bodyType  fuelType  gearbox  power  \\\n",
       "0     736  20040402   30.0      6       1.0       0.0      0.0     60   \n",
       "1    2262  20030301   40.0      1       2.0       0.0      0.0      0   \n",
       "2   14874  20040403  115.0     15       1.0       0.0      0.0    163   \n",
       "3   71865  19960908  109.0     10       0.0       0.0      1.0    193   \n",
       "4  111080  20120103  110.0      5       1.0       0.0      0.0     68   \n",
       "\n",
       "   kilometer notRepairedDamage  ...       v_5       v_6       v_7       v_8  \\\n",
       "0       12.5               0.0  ...  0.235676  0.101988  0.129549  0.022816   \n",
       "1       15.0                 -  ...  0.264777  0.121004  0.135731  0.026597   \n",
       "2       12.5               0.0  ...  0.251410  0.114912  0.165147  0.062173   \n",
       "3       15.0               0.0  ...  0.274293  0.110300  0.121964  0.033395   \n",
       "4        5.0               0.0  ...  0.228036  0.073205  0.091880  0.078819   \n",
       "\n",
       "        v_9      v_10      v_11      v_12      v_13      v_14  \n",
       "0  0.097462 -2.881803  2.804097 -2.420821  0.795292  0.914762  \n",
       "1  0.020582 -4.900482  2.096338 -1.030483 -1.722674  0.245522  \n",
       "2  0.027075 -4.846749  1.803559  1.565330 -0.832687 -0.229963  \n",
       "3  0.000000 -4.509599  1.285940 -0.501868 -2.438353 -0.478699  \n",
       "4  0.121534 -1.896240  0.910783  0.931110  2.834518  1.923482  \n",
       "\n",
       "[5 rows x 30 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['name', 'regDate', 'model', 'brand', 'bodyType', 'fuelType', 'gearbox',\n",
       "       'power', 'kilometer', 'notRepairedDamage', 'regionCode', 'seller',\n",
       "       'offerType', 'creatDate', 'price', 'v_0', 'v_1', 'v_2', 'v_3', 'v_4',\n",
       "       'v_5', 'v_6', 'v_7', 'v_8', 'v_9', 'v_10', 'v_11', 'v_12', 'v_13',\n",
       "       'v_14'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['name', 'regDate', 'model', 'brand', 'bodyType', 'fuelType', 'gearbox',\n",
       "       'power', 'kilometer', 'notRepairedDamage', 'regionCode', 'seller',\n",
       "       'offerType', 'creatDate', 'price', 'v_0', 'v_1', 'v_2', 'v_3', 'v_4',\n",
       "       'v_5', 'v_6', 'v_7', 'v_8', 'v_9', 'v_10', 'v_11', 'v_12', 'v_13',\n",
       "       'v_14'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.1 删除异常值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 这里我包装了一个异常值处理的代码，可以随便调用。\n",
    "def outliers_proc(data, col_name, scale=3):\n",
    "    \"\"\"\n",
    "    用于清洗异常值，默认用 box_plot（scale=3）进行清洗\n",
    "    :param data: 接收 pandas 数据格式\n",
    "    :param col_name: pandas 列名\n",
    "    :param scale: 尺度\n",
    "    :return:\n",
    "    \"\"\"\n",
    "\n",
    "    def box_plot_outliers(data_ser, box_scale):\n",
    "        \"\"\"\n",
    "        利用箱线图去除异常值\n",
    "        :param data_ser: 接收 pandas.Series 数据格式\n",
    "        :param box_scale: 箱线图尺度，\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        iqr = box_scale * (data_ser.quantile(0.75) - data_ser.quantile(0.25))\n",
    "        val_low = data_ser.quantile(0.25) - iqr\n",
    "        val_up = data_ser.quantile(0.75) + iqr\n",
    "        rule_low = (data_ser < val_low)\n",
    "        rule_up = (data_ser > val_up)\n",
    "        return (rule_low, rule_up), (val_low, val_up)\n",
    "\n",
    "    data_n = data.copy()\n",
    "    data_series = data_n[col_name]\n",
    "    rule, value = box_plot_outliers(data_series, box_scale=scale)\n",
    "    index = np.arange(data_series.shape[0])[rule[0] | rule[1]]\n",
    "    print(\"Delete number is: {}\".format(len(index)))\n",
    "    data_n = data_n.drop(index)\n",
    "    data_n.reset_index(drop=True, inplace=True)\n",
    "    print(\"Now column number is: {}\".format(data_n.shape[0]))\n",
    "    index_low = np.arange(data_series.shape[0])[rule[0]]\n",
    "    outliers = data_series.iloc[index_low]\n",
    "    print(\"Description of data less than the lower bound is:\")\n",
    "    print(pd.Series(outliers).describe())\n",
    "    index_up = np.arange(data_series.shape[0])[rule[1]]\n",
    "    outliers = data_series.iloc[index_up]\n",
    "    print(\"Description of data larger than the upper bound is:\")\n",
    "    print(pd.Series(outliers).describe())\n",
    "    \n",
    "    fig, ax = plt.subplots(1, 2, figsize=(10, 7))\n",
    "    sns.boxplot(y=data[col_name], data=data, palette=\"Set1\", ax=ax[0])\n",
    "    sns.boxplot(y=data_n[col_name], data=data_n, palette=\"Set1\", ax=ax[1])\n",
    "    return data_n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Delete number is: 963\n",
      "Now column number is: 149037\n",
      "Description of data less than the lower bound is:\n",
      "count    0.0\n",
      "mean     NaN\n",
      "std      NaN\n",
      "min      NaN\n",
      "25%      NaN\n",
      "50%      NaN\n",
      "75%      NaN\n",
      "max      NaN\n",
      "Name: power, dtype: float64\n",
      "Description of data larger than the upper bound is:\n",
      "count      963.000000\n",
      "mean       846.836968\n",
      "std       1929.418081\n",
      "min        376.000000\n",
      "25%        400.000000\n",
      "50%        436.000000\n",
      "75%        514.000000\n",
      "max      19312.000000\n",
      "Name: power, dtype: float64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们可以删掉一些异常数据，以 power 为例。  \n",
    "# 这里删不删同学可以自行判断\n",
    "# 但是要注意 test 的数据不能删 = = 不能掩耳盗铃是不是\n",
    "\n",
    "train = outliers_proc(train, 'power', scale=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.2 特征构造"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练集和测试集放在一起，方便构造特征\n",
    "train['train']=1\n",
    "test['train']=0\n",
    "data = pd.concat([train, test], ignore_index=True, sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用时间：data['creatDate'] - data['regDate']，反应汽车使用时间，一般来说价格与使用时间成反比\n",
    "# 不过要注意，数据里有时间出错的格式，所以我们需要 errors='coerce'\n",
    "data['used_time'] = (pd.to_datetime(data['creatDate'], format='%Y%m%d', errors='coerce') - \n",
    "                            pd.to_datetime(data['regDate'], format='%Y%m%d', errors='coerce')).dt.days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15072"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 看一下空数据，有 15k 个样本的时间是有问题的，我们可以选择删除，也可以选择放着。\n",
    "# 但是这里不建议删除，因为删除缺失数据占总样本量过大，7.5%\n",
    "# 我们可以先放着，因为如果我们 XGBoost 之类的决策树，其本身就能处理缺失值，所以可以不用管；\n",
    "data['used_time'].isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 从邮编中提取城市信息，因为是德国的数据，所以参考德国的邮编，相当于加入了先验知识\n",
    "data['city'] = data['regionCode'].apply(lambda x : str(x)[:-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算某品牌的销售统计量，同学们还可以计算其他特征的统计量\n",
    "# 这里要以 train 的数据计算统计量\n",
    "train_gb = train.groupby(\"brand\")\n",
    "all_info = {}\n",
    "for kind, kind_data in train_gb:\n",
    "    info = {}\n",
    "    kind_data = kind_data[kind_data['price'] > 0]\n",
    "    info['brand_amount'] = len(kind_data)\n",
    "    info['brand_price_max'] = kind_data.price.max()\n",
    "    info['brand_price_median'] = kind_data.price.median()\n",
    "    info['brand_price_min'] = kind_data.price.min()\n",
    "    info['brand_price_sum'] = kind_data.price.sum()\n",
    "    info['brand_price_std'] = kind_data.price.std()\n",
    "    info['brand_price_average'] = round(kind_data.price.sum() / (len(kind_data) + 1), 2)\n",
    "    all_info[kind] = info\n",
    "brand_fe = pd.DataFrame(all_info).T.reset_index().rename(columns={\"index\": \"brand\"})\n",
    "data = data.merge(brand_fe, how='left', on='brand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>power_bin</th>\n",
       "      <th>power</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.0</td>\n",
       "      <td>60</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>NaN</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>16.0</td>\n",
       "      <td>163</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>19.0</td>\n",
       "      <td>193</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6.0</td>\n",
       "      <td>68</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   power_bin  power\n",
       "0        5.0     60\n",
       "1        NaN      0\n",
       "2       16.0    163\n",
       "3       19.0    193\n",
       "4        6.0     68"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 数据分桶 以 power 为例\n",
    "# 这时候我们的缺失值也进桶了，\n",
    "# 为什么要做数据分桶呢，原因有很多，= =\n",
    "# 1. 离散后稀疏向量内积乘法运算速度更快，计算结果也方便存储，容易扩展；\n",
    "# 2. 离散后的特征对异常值更具鲁棒性，如 age>30 为 1 否则为 0，对于年龄为 200 的也不会对模型造成很大的干扰；\n",
    "# 3. LR 属于广义线性模型，表达能力有限，经过离散化后，每个变量有单独的权重，这相当于引入了非线性，能够提升模型的表达能力，加大拟合；\n",
    "# 4. 离散后特征可以进行特征交叉，提升表达能力，由 M+N 个变量编程 M*N 个变量，进一步引入非线形，提升了表达能力；\n",
    "# 5. 特征离散后模型更稳定，如用户年龄区间，不会因为用户年龄长了一岁就变化\n",
    "\n",
    "# 当然还有很多原因，LightGBM 在改进 XGBoost 时就增加了数据分桶，增强了模型的泛化性\n",
    "\n",
    "bin = [i*10 for i in range(31)]\n",
    "data['power_bin'] = pd.cut(data['power'], bin, labels=False)\n",
    "data[['power_bin', 'power']].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 利用好了，就可以删掉原始数据了\n",
    "data = data.drop(['creatDate', 'regDate', 'regionCode'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(199037, 38)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index(['name', 'model', 'brand', 'bodyType', 'fuelType', 'gearbox', 'power',\n",
       "       'kilometer', 'notRepairedDamage', 'seller', 'offerType', 'price', 'v_0',\n",
       "       'v_1', 'v_2', 'v_3', 'v_4', 'v_5', 'v_6', 'v_7', 'v_8', 'v_9', 'v_10',\n",
       "       'v_11', 'v_12', 'v_13', 'v_14', 'train', 'used_time', 'city',\n",
       "       'brand_amount', 'brand_price_average', 'brand_price_max',\n",
       "       'brand_price_median', 'brand_price_min', 'brand_price_std',\n",
       "       'brand_price_sum', 'power_bin'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data.shape)\n",
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 目前的数据其实已经可以给树模型使用了，所以我们导出一下\n",
    "data.to_csv('data_for_tree.csv', index=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x12904e5c0>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们可以再构造一份特征给 LR NN 之类的模型用\n",
    "# 之所以分开构造是因为，不同模型对数据集的要求不同\n",
    "# 我们看下数据分布：\n",
    "data['power'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x12de6bba8>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们刚刚已经对 train 进行异常值处理了，但是现在还有这么奇怪的分布是因为 test 中的 power 异常值，\n",
    "# 所以我们其实刚刚 train 中的 power 异常值不删为好，可以用长尾分布截断来代替\n",
    "train['power'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x129ad5dd8>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们对其取 log，在做归一化\n",
    "from sklearn import preprocessing\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "data['power'] = np.log(data['power'] + 1) \n",
    "data['power'] = ((data['power'] - np.min(data['power'])) / (np.max(data['power']) - np.min(data['power'])))\n",
    "data['power'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x12de58cf8>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# km 的比较正常，应该是已经做过分桶了\n",
    "data['kilometer'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x128b4fd30>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAAD4CAYAAAAgs6s2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAWeElEQVR4nO3df7BfdX3n8efLRH618ktS1k2gwTW1jbSOmCIdp601FQO0hG3VhWmXaDNkt2JrW2crtDubVmVGpq1UdtRKl6zAWhGplewKm40IdXZnA4Ti8lPKXUBJREkJwioVGnzvH9/P1a/h3uSbe8/3+/Xe+3zM3LnnvM/nnPP5kDCvnHM+3/NNVSFJUpdeMO4OSJLmH8NFktQ5w0WS1DnDRZLUOcNFktS5xePuwA+KY445ppYvXz7ubkjSnHL77bf/Q1Ut2btuuDTLly9n+/bt4+6GJM0pSb48Vd3bYpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM75CX1J+gGw/ILPju3cD7//jM6P6ZWLJKlzhoskqXOGiySpc4aLJKlzhoskqXOGiySpc4aLJKlzhoskqXOGiySpc4aLJKlzQwuXJJuSPJbk7r7anyT5UpI7k/xNkiP7tl2YZCLJ/Une2Fdf02oTSS7oq5+Q5JZW/2SSg1r94LY+0bYvH9YYJUlTG+aVy8eANXvVtgInVtVPAX8PXAiQZCVwNvCKts+HkyxKsgj4EHAasBI4p7UFuBi4pKpeBjwBrG/19cATrX5JaydJGqGhhUtVfQHYvVftf1TVnra6DVjWltcCV1fVM1X1EDABnNx+Jqrqwap6FrgaWJskwOuBa9v+VwBn9R3rirZ8LbC6tZckjcg4n7n8BnBDW14KPNK3bUerTVd/MfCNvqCarH/fsdr2J1v750myIcn2JNt37do16wFJknrGEi5J/hDYA3x8HOefVFWXVdWqqlq1ZMmScXZFkuaVkX+fS5K3Ar8ErK6qauWdwHF9zZa1GtPUHweOTLK4XZ30t5881o4ki4EjWntJ0oiM9MolyRrg94Ezq+rpvk2bgbPbTK8TgBXArcBtwIo2M+wgeg/9N7dQugl4U9t/HXBd37HWteU3AZ/vCzFJ0ggM7colySeA1wHHJNkBbKQ3O+xgYGt7xr6tqv5tVd2T5BrgXnq3y86vqufacd4BbAEWAZuq6p52incDVyd5H3AHcHmrXw5clWSC3oSCs4c1RknS1IYWLlV1zhTly6eoTba/CLhoivr1wPVT1B+kN5ts7/q3gTcfUGclSZ3yE/qSpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzg0tXJJsSvJYkrv7akcn2Zrkgfb7qFZPkkuTTCS5M8lJffusa+0fSLKur/7qJHe1fS5Nkn2dQ5I0OsO8cvkYsGav2gXAjVW1ArixrQOcBqxoPxuAj0AvKICNwGuAk4GNfWHxEeC8vv3W7OcckqQRGVq4VNUXgN17ldcCV7TlK4Cz+upXVs824MgkLwHeCGytqt1V9QSwFVjTth1eVduqqoAr9zrWVOeQJI3IqJ+5HFtVj7blrwHHtuWlwCN97Xa02r7qO6ao7+scz5NkQ5LtSbbv2rVrBsORJE1lbA/02xVHjfMcVXVZVa2qqlVLliwZZlckaUEZdbh8vd3Sov1+rNV3Asf1tVvWavuqL5uivq9zSJJGZNThshmYnPG1Driur35umzV2CvBku7W1BTg1yVHtQf6pwJa27akkp7RZYufudaypziFJGpHFwzpwkk8ArwOOSbKD3qyv9wPXJFkPfBl4S2t+PXA6MAE8DbwNoKp2J3kvcFtr956qmpwk8HZ6M9IOBW5oP+zjHJKkERlauFTVOdNsWj1F2wLOn+Y4m4BNU9S3AydOUX98qnNIkkbHT+hLkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjpnuEiSOme4SJI6Z7hIkjo3ULgk+clhd0SSNH8MeuXy4SS3Jnl7kiNme9Ikv5vkniR3J/lEkkOSnJDkliQTST6Z5KDW9uC2PtG2L+87zoWtfn+SN/bV17TaRJILZttfSdKBGShcqupngV8DjgNuT/JXSd4wkxMmWQr8NrCqqk4EFgFnAxcDl1TVy4AngPVtl/XAE61+SWtHkpVtv1cAa+gF4KIki4APAacBK4FzWltJ0ogM/Mylqh4A/j3wbuDngUuTfCnJr8zgvIuBQ5MsBg4DHgVeD1zbtl8BnNWW17Z12vbVSdLqV1fVM1X1EDABnNx+Jqrqwap6Fri6tZUkjcigz1x+KsklwH30QuCXq+on2vIlB3LCqtoJ/CnwFXqh8iRwO/CNqtrTmu0AlrblpcAjbd89rf2L++t77TNdfapxbUiyPcn2Xbt2HcgwJEn7MOiVy38E/g54ZVWdX1V/B1BVX6V3NTOwJEfRu5I4AfjnwA/Ru601clV1WVWtqqpVS5YsGUcXJGleWjxguzOAf6yq5wCSvAA4pKqerqqrDvCcvwg8VFW72rE+DbwWODLJ4nZ1sgzY2drvpPesZ0e7jXYE8HhffVL/PtPVJUkjMOiVy+eAQ/vWD2u1mfgKcEqSw9qzk9XAvcBNwJtam3XAdW15c1unbf98VVWrn91mk50ArABuBW4DVrTZZwfRe+i/eYZ9lSTNwKBXLodU1TcnV6rqm0kOm8kJq+qWJNfSu822B7gDuAz4LHB1kve12uVtl8uBq5JMALvphQVVdU+Sa+gF0x7g/L4rq3cAW+jNRNtUVffMpK+SpJkZNFy+leSkyWctSV4N/ONMT1pVG4GNe5UfpDfTa++23wbePM1xLgIumqJ+PXD9TPsnSZqdQcPld4BPJfkqEOCfAf9qaL2SJM1pA4VLVd2W5MeBl7fS/VX1T8PrliRpLhv0ygXgp4HlbZ+TklBVVw6lV5KkOW2gcElyFfAvgC8Cz7VyAYaLJOl5Br1yWQWsbFOAJUnap0E/53I3vYf4kiTt16BXLscA9ya5FXhmslhVZw6lV5KkOW3QcPmjYXZCkjS/DDoV+W+T/Ciwoqo+1z6dv2i4XZMkzVWDvnL/PHrfpfLRVloKfGZYnZIkzW2DPtA/n96bi5+C735x2I8Mq1OSpLlt0HB5pn2rIwDt1fdOS5YkTWnQcPnbJH9A76uJ3wB8Cvivw+uWJGkuGzRcLgB2AXcB/4beG4cP6BsoJUkLx6Czxb4D/GX7kSRpnwZ9t9hDTPGMpape2nmPJElz3oG8W2zSIfS+vOvo7rsjSZoPBnrmUlWP9/3srKo/B84Yct8kSXPUoLfFTupbfQG9K5kD+S4YSdICMmhA/Fnf8h7gYeAtnfdGkjQvDDpb7BeG3RFJ0vwx6G2x39vX9qr6QDfdkSTNBwcyW+yngc1t/ZeBW4EHhtEpSdLcNugn9JcBJ1XVu6rqXcCrgeOr6o+r6o8P9KRJjkxybZIvJbkvyc8kOTrJ1iQPtN9HtbZJcmmSiSR39k8uSLKutX8gybq++quT3NX2uTRJDrSPkqSZGzRcjgWe7Vt/ttVm6oPAf6+qHwdeCdxH7xUzN1bVCuDGtg5wGrCi/WwAPgKQ5GhgI/Aa4GRg42QgtTbn9e23ZhZ9lSQdoEFvi10J3Jrkb9r6WcAVMzlhkiOAnwPeCtDetvxskrXA61qzK4CbgXcDa4Erq6qAbe2q5yWt7daq2t2OuxVYk+Rm4PCq2tbqV7b+3jCT/kqSDtygs8UuSnID8LOt9LaqumOG5zyB3ksw/3OSVwK3A+8Ejq2qR1ubr/G9K6OlwCN9++9otX3Vd0xRf54kG+hdDXH88cfPcDiSpL0NelsM4DDgqar6ILAjyQkzPOdi4CTgI1X1KuBbfO8WGADtKmXo3xdTVZdV1aqqWrVkyZJhn06SFoxBv+Z4I71bVBe20guB/zLDc+4AdlTVLW39Wnph8/V2u4v2+7G2fSdwXN/+y1ptX/VlU9QlSSMy6JXLvwTOpHeVQVV9FXjRTE5YVV8DHkny8lZaDdxLb5rz5IyvdcB1bXkzcG6bNXYK8GS7fbYFODXJUe1B/qnAlrbtqSSntFli5/YdS5I0AoM+0H+2qipJAST5oVme97eAjyc5CHgQeBu9oLsmyXrgy3zv9TLXA6cDE8DTrS1VtTvJe4HbWrv3TD7cB94OfAw4lN6DfB/mS9IIDRou1yT5KHBkkvOA32AWXxxWVV/k+1/jP2n1FG0LOH+a42wCNk1R3w6cONP+SZJmZ9DZYn+a5A3AU8DLgf9QVVuH2jNJ0py133BJsgj4XHt5pYEiSdqv/T7Qr6rngO+0Dz9KkrRfgz5z+SZwV/sU/Lcmi1X120PplSRpThs0XD7dfiRJ2q99hkuS46vqK1U1o/eISZIWpv09c/nM5EKSvx5yXyRJ88T+wqX/e1BeOsyOSJLmj/2FS02zLEnStPb3QP+VSZ6idwVzaFumrVdVHT7U3kmS5qR9hktVLRpVRyRJ88eBfJ+LJEkDMVwkSZ0zXCRJnTNcJEmdM1wkSZ0zXCRJnTNcJEmdM1wkSZ0zXCRJnTNcJEmdM1wkSZ0zXCRJnRtbuCRZlOSOJP+trZ+Q5JYkE0k+meSgVj+4rU+07cv7jnFhq9+f5I199TWtNpHkglGPTZIWunFeubwTuK9v/WLgkqp6GfAEsL7V1wNPtPolrR1JVgJnA68A1gAfboG1CPgQcBqwEjintZUkjchYwiXJMuAM4D+19QCvB65tTa4AzmrLa9s6bfvq1n4tcHVVPVNVDwETwMntZ6KqHqyqZ4GrW1tJ0oiM68rlz4HfB77T1l8MfKOq9rT1HcDStrwUeASgbX+ytf9ufa99pqs/T5INSbYn2b5r167ZjkmS1Iw8XJL8EvBYVd0+6nPvraouq6pVVbVqyZIl4+6OJM0b+/ua42F4LXBmktOBQ4DDgQ8CRyZZ3K5OlgE7W/udwHHAjiSLgSOAx/vqk/r3ma4uSRqBkV+5VNWFVbWsqpbTeyD/+ar6NeAm4E2t2Trgura8ua3Ttn++qqrVz26zyU4AVgC3ArcBK9rss4PaOTaPYGiSpGYcVy7TeTdwdZL3AXcAl7f65cBVSSaA3fTCgqq6J8k1wL3AHuD8qnoOIMk7gC3AImBTVd0z0pFI0gI31nCpqpuBm9vyg/Rmeu3d5tvAm6fZ/yLgoinq1wPXd9hVSdIB8BP6kqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTOGS6SpM6NPFySHJfkpiT3JrknyTtb/egkW5M80H4f1epJcmmSiSR3Jjmp71jrWvsHkqzrq786yV1tn0uTZNTjlKSFbBxXLnuAd1XVSuAU4PwkK4ELgBuragVwY1sHOA1Y0X42AB+BXhgBG4HXACcDGycDqbU5r2+/NSMYlySpWTzqE1bVo8Cjbfn/JbkPWAqsBV7Xml0B3Ay8u9WvrKoCtiU5MslLWtutVbUbIMlWYE2Sm4HDq2pbq18JnAXcMIrxSZrbll/w2XF3YV4Y6zOXJMuBVwG3AMe24AH4GnBsW14KPNK3245W21d9xxR1SdKIjC1ckvww8NfA71TVU/3b2lVKjaAPG5JsT7J9165dwz6dJC0YYwmXJC+kFywfr6pPt/LX2+0u2u/HWn0ncFzf7stabV/1ZVPUn6eqLquqVVW1asmSJbMblCTpu8YxWyzA5cB9VfWBvk2bgckZX+uA6/rq57ZZY6cAT7bbZ1uAU5Mc1R7knwpsadueSnJKO9e5fceSJI3AyB/oA68F/jVwV5IvttofAO8HrkmyHvgy8Ja27XrgdGACeBp4G0BV7U7yXuC21u49kw/3gbcDHwMOpfcg34f5kjRC45gt9j+B6T53snqK9gWcP82xNgGbpqhvB06cRTclSbPgJ/QlSZ0zXCRJnTNcJEmdM1wkSZ0zXCRJnTNcJEmdG8fnXCQdgHG+SPHh958xtnNrbvPKRZLUOcNFktQ5w0WS1DnDRZLUOcNFktQ5Z4tpTnHmlDQ3GC6SpjWuMDfI5z5vi0mSOme4SJI6Z7hIkjrnM5c5znvikn4QGS7SgMY5U02aa7wtJknqnOEiSeqct8U6sBBvlyzEMUsanFcukqTOGS6SpM7N23BJsibJ/Ukmklww7v5I0kIyL8MlySLgQ8BpwErgnCQrx9srSVo45mW4ACcDE1X1YFU9C1wNrB1znyRpwZivs8WWAo/0re8AXrN3oyQbgA1t9ZtJ7p/h+Y4B/mGG+85VjnlhGMuYc/Goz/h9Ftyfcy6e1Zh/dKrifA2XgVTVZcBlsz1Oku1VtaqDLs0ZjnlhcMwLwzDGPF9vi+0EjutbX9ZqkqQRmK/hchuwIskJSQ4CzgY2j7lPkrRgzMvbYlW1J8k7gC3AImBTVd0zxFPO+tbaHOSYFwbHvDB0PuZUVdfHlCQtcPP1tpgkaYwMF0lS5wyXA7C/V8okOTjJJ9v2W5IsH30vuzXAmH8vyb1J7kxyY5Ip57zPJYO+OijJryapJHN62uog403ylvbnfE+Svxp1H7s2wN/r45PclOSO9nf79HH0s0tJNiV5LMnd02xPkkvbf5M7k5w0qxNWlT8D/NCbGPB/gZcCBwH/B1i5V5u3A3/Rls8GPjnufo9gzL8AHNaWf3MhjLm1exHwBWAbsGrc/R7yn/EK4A7gqLb+I+Pu9wjGfBnwm215JfDwuPvdwbh/DjgJuHua7acDNwABTgFumc35vHIZ3CCvlFkLXNGWrwVWJ8kI+9i1/Y65qm6qqqfb6jZ6nymaywZ9ddB7gYuBb4+yc0MwyHjPAz5UVU8AVNVjI+5j1wYZcwGHt+UjgK+OsH9DUVVfAHbvo8la4Mrq2QYcmeQlMz2f4TK4qV4ps3S6NlW1B3gSePFIejccg4y533p6//KZy/Y75na74Liqmg/fmDbIn/GPAT+W5H8l2ZZkzch6NxyDjPmPgF9PsgO4Hvit0XRtrA70//d9mpefc9HoJfl1YBXw8+PuyzAleQHwAeCtY+7KKC2md2vsdfSuTL+Q5Cer6htj7dVwnQN8rKr+LMnPAFclObGqvjPujs0VXrkMbpBXyny3TZLF9C6nHx9J74ZjoNfoJPlF4A+BM6vqmRH1bVj2N+YXAScCNyd5mN696c1z+KH+IH/GO4DNVfVPVfUQ8Pf0wmauGmTM64FrAKrqfwOH0Huh5XzW6WuzDJfBDfJKmc3Aurb8JuDz1Z6UzVH7HXOSVwEfpRcsc/1ePOxnzFX1ZFUdU1XLq2o5vedMZ1bV9vF0d9YG+Xv9GXpXLSQ5ht5tsgdH2cmODTLmrwCrAZL8BL1w2TXSXo7eZuDcNmvsFODJqnp0pgfzttiAappXyiR5D7C9qjYDl9O7fJ6g9+Ds7PH1ePYGHPOfAD8MfKrNXfhKVZ05tk7P0oBjnjcGHO8W4NQk9wLPAf+uqubsFfmAY34X8JdJfpfew/23zvF/KJLkE/T+kXBMe5a0EXghQFX9Bb1nS6cDE8DTwNtmdb45/t9LkvQDyNtikqTOGS6SpM4ZLpKkzhkukqTOGS6SpM4ZLpKkzhkukqTO/X8WkShU7M/pKwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 所以我们可以直接做归一化\n",
    "data['kilometer'] = ((data['kilometer'] - np.min(data['kilometer'])) / \n",
    "                        (np.max(data['kilometer']) - np.min(data['kilometer'])))\n",
    "data['kilometer'].plot.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 除此之外 还有我们刚刚构造的统计量特征：\n",
    "# 'brand_amount', 'brand_price_average', 'brand_price_max',\n",
    "# 'brand_price_median', 'brand_price_min', 'brand_price_std',\n",
    "# 'brand_price_sum'\n",
    "# 这里不再一一举例分析了，直接做变换，\n",
    "def max_min(x):\n",
    "    return (x - np.min(x)) / (np.max(x) - np.min(x))\n",
    "\n",
    "data['brand_amount'] = ((data['brand_amount'] - np.min(data['brand_amount'])) / \n",
    "                        (np.max(data['brand_amount']) - np.min(data['brand_amount'])))\n",
    "data['brand_price_average'] = ((data['brand_price_average'] - np.min(data['brand_price_average'])) / \n",
    "                               (np.max(data['brand_price_average']) - np.min(data['brand_price_average'])))\n",
    "data['brand_price_max'] = ((data['brand_price_max'] - np.min(data['brand_price_max'])) / \n",
    "                           (np.max(data['brand_price_max']) - np.min(data['brand_price_max'])))\n",
    "data['brand_price_median'] = ((data['brand_price_median'] - np.min(data['brand_price_median'])) /\n",
    "                              (np.max(data['brand_price_median']) - np.min(data['brand_price_median'])))\n",
    "data['brand_price_min'] = ((data['brand_price_min'] - np.min(data['brand_price_min'])) / \n",
    "                           (np.max(data['brand_price_min']) - np.min(data['brand_price_min'])))\n",
    "data['brand_price_std'] = ((data['brand_price_std'] - np.min(data['brand_price_std'])) / \n",
    "                           (np.max(data['brand_price_std']) - np.min(data['brand_price_std'])))\n",
    "data['brand_price_sum'] = ((data['brand_price_sum'] - np.min(data['brand_price_sum'])) / \n",
    "                           (np.max(data['brand_price_sum']) - np.min(data['brand_price_sum'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 对类别特征进行 OneEncoder\n",
    "data = pd.get_dummies(data, columns=['model', 'brand', 'bodyType', 'fuelType',\n",
    "                                     'gearbox', 'notRepairedDamage', 'power_bin'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(199037, 369)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Index(['name', 'power', 'kilometer', 'seller', 'offerType', 'price', 'v_0',\n",
       "       'v_1', 'v_2', 'v_3',\n",
       "       ...\n",
       "       'power_bin_20.0', 'power_bin_21.0', 'power_bin_22.0', 'power_bin_23.0',\n",
       "       'power_bin_24.0', 'power_bin_25.0', 'power_bin_26.0', 'power_bin_27.0',\n",
       "       'power_bin_28.0', 'power_bin_29.0'],\n",
       "      dtype='object', length=369)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data.shape)\n",
    "data.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 这份数据可以给 LR 用\n",
    "data.to_csv('data_for_lr.csv', index=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3.3 特征筛选"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1) 过滤式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5737373458520139\n",
      "-0.4093147076627742\n",
      "0.0579639618400197\n",
      "0.38587089498185884\n",
      "0.26142364388130207\n",
      "0.3891431767902722\n"
     ]
    }
   ],
   "source": [
    "# 相关性分析\n",
    "print(data['power'].corr(data['price'], method='spearman'))\n",
    "print(data['kilometer'].corr(data['price'], method='spearman'))\n",
    "print(data['brand_amount'].corr(data['price'], method='spearman'))\n",
    "print(data['brand_price_average'].corr(data['price'], method='spearman'))\n",
    "print(data['brand_price_max'].corr(data['price'], method='spearman'))\n",
    "print(data['brand_price_median'].corr(data['price'], method='spearman'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x129059470>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 当然也可以直接看图\n",
    "data_numeric = data[['power', 'kilometer', 'brand_amount', 'brand_price_average', \n",
    "                     'brand_price_max', 'brand_price_median']]\n",
    "correlation = data_numeric.corr()\n",
    "\n",
    "f , ax = plt.subplots(figsize = (7, 7))\n",
    "plt.title('Correlation of Numeric Features with Price',y=1,size=16)\n",
    "sns.heatmap(correlation,square = True,  vmax=0.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2) 包裹式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install mlxtend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "STOPPING EARLY DUE TO KEYBOARD INTERRUPT..."
     ]
    },
    {
     "data": {
      "text/plain": [
       "('powerPS_ten',\n",
       " 'city',\n",
       " 'brand_price_std',\n",
       " 'vehicleType_andere',\n",
       " 'model_145',\n",
       " 'model_601',\n",
       " 'fuelType_andere',\n",
       " 'notRepairedDamage_ja')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# k_feature 太大会很难跑，没服务器，所以提前 interrupt 了\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n",
    "from sklearn.linear_model import LinearRegression\n",
    "sfs = SFS(LinearRegression(),\n",
    "           k_features=10,\n",
    "           forward=True,\n",
    "           floating=False,\n",
    "           scoring = 'r2',\n",
    "           cv = 0)\n",
    "x = data.drop(['price'], axis=1)\n",
    "x = x.fillna(0)\n",
    "y = data['price']\n",
    "sfs.fit(x, y)\n",
    "sfs.k_feature_names_ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/chenze/anaconda3/lib/python3.7/site-packages/numpy/core/_methods.py:140: RuntimeWarning: Degrees of freedom <= 0 for slice\n",
      "  keepdims=keepdims)\n",
      "/Users/chenze/anaconda3/lib/python3.7/site-packages/numpy/core/_methods.py:132: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  ret = ret.dtype.type(ret / rcount)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 画出来，可以看到边际效益\n",
    "from mlxtend.plotting import plot_sequential_feature_selection as plot_sfs\n",
    "import matplotlib.pyplot as plt\n",
    "fig1 = plot_sfs(sfs.get_metric_dict(), kind='std_dev')\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3) 嵌入式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 下一章介绍，Lasso 回归和决策树可以完成嵌入式特征选择\n",
    "# 大部分情况下都是用嵌入式做特征筛选"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 经验总结"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "特征工程是比赛中最至关重要的的一块，特别的传统的比赛，大家的模型可能都差不多，调参带来的效果增幅是非常有限的，但特征工程的好坏往往会决定了最终的排名和成绩。\n",
    "\n",
    "特征工程的主要目的还是在于将数据转换为能更好地表示潜在问题的特征，从而提高机器学习的性能。比如，异常值处理是为了去除噪声，填补缺失值可以加入先验知识等。\n",
    "\n",
    "特征构造也属于特征工程的一部分，其目的是为了增强数据的表达。\n",
    "\n",
    "有些比赛的特征是匿名特征，这导致我们并不清楚特征相互直接的关联性，这时我们就只有单纯基于特征进行处理，比如装箱，groupby，agg 等这样一些操作进行一些特征统计，此外还可以对特征进行进一步的 log，exp 等变换，或者对多个特征进行四则运算（如上面我们算出的使用时长），多项式组合等然后进行筛选。由于特性的匿名性其实限制了很多对于特征的处理，当然有些时候用 NN 去提取一些特征也会达到意想不到的良好效果。\n",
    "\n",
    "对于知道特征含义（非匿名）的特征工程，特别是在工业类型比赛中，会基于信号处理，频域提取，丰度，偏度等构建更为有实际意义的特征，这就是结合背景的特征构建，在推荐系统中也是这样的，各种类型点击率统计，各时段统计，加用户属性的统计等等，这样一种特征构建往往要深入分析背后的业务逻辑或者说物理原理，从而才能更好的找到 magic。\n",
    "\n",
    "当然特征工程其实是和模型结合在一起的，这就是为什么要为 LR NN 做分桶和特征归一化的原因，而对于特征的处理效果和特征重要性等往往要通过模型来验证。\n",
    "\n",
    "总的来说，特征工程是一个入门简单，但想精通非常难的一件事。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Task 3-特征工程 END.\n",
    "\n",
    "\n",
    "--- By: 阿泽\n",
    "\n",
    "    PS：复旦大学计算机研究生\n",
    "    知乎：阿泽 https://www.zhihu.com/people/is-aze（主要面向初学者的知识整理）\n",
    "\n",
    "\n",
    "关于Datawhale：\n",
    "\n",
    "> Datawhale是一个专注于数据科学与AI领域的开源组织，汇集了众多领域院校和知名企业的优秀学习者，聚合了一群有开源精神和探索精神的团队成员。Datawhale 以“for the learner，和学习者一起成长”为愿景，鼓励真实地展现自我、开放包容、互信互助、敢于试错和勇于担当。同时 Datawhale 用开源的理念去探索开源内容、开源学习和开源方案，赋能人才培养，助力人才成长，建立起人与人，人与知识，人与企业和人与未来的联结。\n",
    "\n",
    "本次数据挖掘路径学习，专题知识将在天池分享，详情可关注Datawhale：\n",
    "\n",
    "![](http://jupter-oss.oss-cn-hangzhou.aliyuncs.com/public/files/image/1095279172547/1584432602983_kAxAvgQpG2.jpg) \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
